// internal/parser/parser/insert.go
package parser

import (
	"fmt"

	"NumberBase/internal/parser/ast"
	"NumberBase/internal/parser/lexer"
)

// parseInsertStatement 解析INSERT语句
// 例如: INSERT INTO users (id, name) VALUES (1, 'John')
func (p *Parser) parseInsertStatement() (*ast.InsertStatement, error) {
	stmt := &ast.InsertStatement{}

	// 跳过INSERT
	p.nextToken()

	// 期望下一个Token是INTO
	if !p.currTokenIs(lexer.INTO) {
		return nil, fmt.Errorf("期望INTO，但得到%s", p.currToken.Literal)
	}

	// 跳过INTO
	p.nextToken()

	// 解析表名
	if !p.currTokenIs(lexer.IDENTIFIER) {
		return nil, fmt.Errorf("期望表名，但得到%s", p.currToken.Literal)
	}
	stmt.TableName = p.currToken.Literal

	// 处理列名列表(可选)和VALUES子句
	p.nextToken()
	if p.currTokenIs(lexer.LPAREN) {
		// 有列名列表的情况: INSERT INTO users (id, name) VALUES (...)
		columns, err := p.parseIdentifierList()
		if err != nil {
			return nil, err
		}
		stmt.Columns = columns

		// 此时应该在右括号上，下一个应该是VALUES
		if !p.expectPeek(lexer.VALUES) {
			return nil, fmt.Errorf("期望VALUES，但得到%s", p.peekToken.Literal)
		}
	} else if p.currTokenIs(lexer.VALUES) {
		// 没有列名列表的情况: INSERT INTO users VALUES (...)
	} else {
		return nil, fmt.Errorf("期望(或VALUES，但得到%s", p.currToken.Literal)
	}

	// 解析VALUES子句
	p.nextToken() // 跳过VALUES

	// 当前token应该是左括号
	if !p.currTokenIs(lexer.LPAREN) {
		return nil, fmt.Errorf("期望(，但得到%s", p.currToken.Literal)
	}

	// 跳过左括号
	p.nextToken()

	// 解析第一个值
	expr, err := p.parseExpression(LOWEST)
	if err != nil {
		return nil, err
	}
	values := []ast.Expression{expr}

	// 解析后续值
	for p.peekTokenIs(lexer.COMMA) {
		p.nextToken() // 跳过逗号或当前值
		p.nextToken() // 移动到下一个值

		expr, err := p.parseExpression(LOWEST)
		if err != nil {
			return nil, err
		}
		values = append(values, expr)
	}

	// 保存解析到的值
	stmt.Values = values

	// 期望下一个token是右括号
	if !p.expectPeek(lexer.RPAREN) {
		return nil, fmt.Errorf("期望)，但得到%s", p.peekToken.Literal)
	}

	// 检查下一个token是否是分号(作为SQL语句结束标记)
	if p.peekTokenIs(lexer.SEMICOLON) {
		p.nextToken() // 消费分号，确认语句结束
	}
	// 如果没有分号，也允许语句结束（某些SQL环境中分号是可选的）

	return stmt, nil
}
